package com.android.support.lib.universal.utils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.URL;
import java.net.URLConnection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 纯java的Http请求，不需要任何第三方库的支持。也不需要android 6.0之后的org.apache.http.legacy.jar(确认不需要)
 * Created by Administrator on 2017/5/23.
 */

public class UtilHttp {
    private static UtilHttp http;
    private ThreadPoolExecutor threadPoolExecutor;

    private UtilHttp() {
        int corePoolSize = Runtime.getRuntime().availableProcessors() + 2;
        int maxinumPoolSize = corePoolSize * 2 + 1;
        long keepAliveTime = 10;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingDeque<>();
        threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maxinumPoolSize, keepAliveTime, unit, workQueue);
        //Log.e("test", "线程池核心数量:\t" + corePoolSize);
    }

    //初始化
    public static UtilHttp getInstance() {
        if (http == null) {
            http = new UtilHttp();
        }
        return http;
    }

    //回调接口
    public interface RequestCallBack {
        //true 已经本地处理，不用访问网络，false继续访问网络
        public boolean onStart();

        //成功
        public void onSuccess(String result);

        //访问失败
        public void onFailure(String result);
    }

    /**
     * Get请求【使用了线程池，无论UI主线程还是后台线程都可执行】
     *
     * @param url             发送请求的 URL
     * @param params          请求参数 Map集合(方法内部会自动拼接成 name1=value1&name2=value2 的字符串形式)
     * @param RequestCallBack 回调接口
     */
    public void sendGet(final String url, final Map<String, String> params, final RequestCallBack RequestCallBack) {
        threadPoolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                if (RequestCallBack != null) {
                    if (RequestCallBack.onStart()) {
                        return;//返回true,本地已经处理。不需再进行网络访问。
                    }
                }
                try {
                    String result = "";
                    BufferedReader in = null;
                    String urlNameString = url;
                    if (params != null) {
                        StringBuffer sb = new StringBuffer();
                        for (Map.Entry<String, String> e : params.entrySet()) {
                            sb.append(e.getKey());
                            sb.append("=");
                            sb.append(e.getValue());
                            sb.append("&");
                        }
                        urlNameString = urlNameString + "?" + sb.substring(0, sb.length() - 1);
                    }
                    //Log.e("test","url:\t"+urlNameString);
                    URL realUrl = new URL(urlNameString);
                    // 打开和URL之间的连接
                    URLConnection connection = realUrl.openConnection();
                    connection.setConnectTimeout(2000);//超时连接，超过这个时间还没连接上，就会连接失败。时间设置决定有效。
                    // 设置通用的请求属性
                    connection.setRequestProperty("accept", "*/*");
                    connection.setRequestProperty("connection", "Keep-Alive");
                    connection.setRequestProperty("user-agent",
                            "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
                    // 建立实际的连接
                    connection.connect();
                    // 获取所有响应头字段
                    Map<String, List<String>> map = connection.getHeaderFields();
                    // 遍历所有的响应头字段
                    for (String key : map.keySet()) {
                        System.out.println(key + "--->" + map.get(key));
                    }
                    // 定义 BufferedReader输入流来读取URL的响应
                    in = new BufferedReader(new InputStreamReader(
                            connection.getInputStream()));
                    String line;
                    while ((line = in.readLine()) != null) {
                        result += line;
                    }
                    // 使用finally块来关闭输入流
                    try {
                        if (in != null) {
                            in.close();
                        }
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                    if (RequestCallBack != null) {
                        RequestCallBack.onSuccess(result);
                    }
                } catch (Exception e) {
                    if (RequestCallBack != null) {
                        RequestCallBack.onFailure(e.getMessage());
                    }
                }
            }
        });
    }

    /**
     * Post请求【使用了线程池，无论UI主线程还是后台线程都可执行】
     *
     * @param url             发送请求的 URL
     * @param params          请求参数 Map集合(方法内部会自动拼接成 name1=value1&name2=value2 的字符串形式)
     * @param RequestCallBack 回调接口
     */
    public void sendPost(final String url, final Map<String, String> params, final RequestCallBack RequestCallBack) {
        threadPoolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                if (RequestCallBack != null) {
                    if (RequestCallBack.onStart()) {
                        return;
                    }
                }
                try {
                    PrintWriter out = null;
                    BufferedReader in = null;
                    String result = "";
                    URL realUrl = new URL(url);
                    // 打开和URL之间的连接
                    URLConnection conn = realUrl.openConnection();
                    conn.setConnectTimeout(2000);//超时连接，超过这个时间还没连接上，就会连接失败
                    // 设置通用的请求属性
                    conn.setRequestProperty("accept", "*/*");
                    conn.setRequestProperty("connection", "Keep-Alive");
                    conn.setRequestProperty("user-agent",
                            "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
                    // 发送POST请求必须设置如下两行
                    conn.setDoOutput(true);
                    conn.setDoInput(true);
                    // 获取URLConnection对象对应的输出流
                    out = new PrintWriter(conn.getOutputStream());
                    // 发送请求参数
                    if (params != null) {
                        StringBuffer sb = new StringBuffer();
                        for (Map.Entry<String, String> e : params.entrySet()) {
                            sb.append(e.getKey());
                            sb.append("=");
                            sb.append(e.getValue());
                            sb.append("&");
                        }
                        out.print(sb.substring(0, sb.length() - 1));
                    }
                    // flush输出流的缓冲
                    out.flush();
                    // 定义BufferedReader输入流来读取URL的响应
                    in = new BufferedReader(
                            new InputStreamReader(conn.getInputStream(), "UTF-8"));
                    String line;
                    while ((line = in.readLine()) != null) {
                        result += line;
                    }
                    try {
                        if (out != null) {
                            out.close();
                        }
                        if (in != null) {
                            in.close();
                        }
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                    if (RequestCallBack != null) {
                        RequestCallBack.onSuccess(result);
                    }
                } catch (Exception e) {
                    if (RequestCallBack != null) {
                        RequestCallBack.onFailure(e.getMessage());
                    }
                }
            }
        });
    }
}
